warning: enum 'OperatorKind' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size]

  enum OperatorKind {
       ^

warning: function-like macro 'OVERLOADED_OPERATOR' used; consider a 'constexpr' template function [cppcoreguidelines-macro-usage]

#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary,            \
        ^

That type of check should be disabled in our clang-tidy config..

I guess we won't or these, 1,2,3 should be fine...

warning: enum 'OperatorArity' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size]

  enum OperatorArity { kUnary = 1, kBinary, kBoth };
       ^

warning: redundant explicit casting to the same type 'Expr *' as the sub-expression, remove this casting [readability-redundant-casting]

  Expr *getDefaultArg();
        ^

warning: do not use C-style cast to convert between unrelated types [cppcoreguidelines-pro-type-cstyle-cast]

    auto *D = (clang::Decl *)method;
              ^

warning: do not use C-style cast to convert between unrelated types [cppcoreguidelines-pro-type-cstyle-cast]

    auto *D = (clang::Decl *)func;
              ^

warning: Called C++ object pointer is null [clang-analyzer-core.CallAndMessage]

    return PI->getNameAsString();
           ^

    clang::ParmVarDecl* PI = nullptr;
    ^

    if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionDecl>(D))
                   ^

    if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionDecl>(D))
              ^

    if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionDecl>(D))
    ^

    else if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(D))
                        ^

    else if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(D))
                   ^

    else if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(D))
         ^

    return PI->getNameAsString();
           ^

I did not understand this.
All Unary operators are not Binary operators. So kBoth = 0 and kUnary = 0 is confusing. Example ~ operator.

Sorry, my bad, fixed the suggestion.

That type of check should be disabled in our clang-tidy config..

We should move that into a utility function, write the switch such that it returns

OperatorArity getOperatorArity(...) {
  if (Unary && Binary) return kBoth; ...
}

warning: enum 'OperatorArity' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size]

  enum OperatorArity { kNone, kUnary, kBinary, kBoth };
       ^

That should be unreachable, right? What does it mean arity::kNone? An operator without arguments? I do not think that's possible.

Yes, should be unreachable.
It is for cases when the argument is something other than an operator or a function that is not an operator.

Shouldn't that be an assert or an early exit?

I will say this is simpler. Assert will crash the program. In this case, the user can handle kNone as an error.

Also if I remove the return, clang-tidy will get angry.

Let me know if you still think we should remove kNone. I can do that, but not sure how I would satisfy clang-tidy's message of Non-void function does not return a value in all control paths.

You should remove it. You can return ~0U

Compiler error:

/home/vipul-cariappa/Workspace/cpp-py/compiler-research/CppInterOp/lib/Interpreter/CppInterOp.cpp:3339:12: error: invalid conversion from ‘unsigned int’ to ‘Cpp::OperatorArity’ [-fpermissive]
 3339 |     return ~0U;
      |            ^~~
      |            |
      |            unsigned int

Should I rename it to kInvalid instead?

Cast it to OperatorArity?

When kind = kBoth should we return Unary $\cap$ Binary or Unary $\cup$ Binary?
This logic using & returns Unary $\cup$ Binary.
Whereas == will return Unary $\cap$ Binary.

Operators like - is both Unary and Binary.

I set the enum OperatorArity values so that I can perform this bitwise operation.

When I say kBoth, I expect all unary and binary operators to be present in that list.

In that case, we should be using &. kUnary = 0b001 and kBinary = 0b010 and kBoth = kUnary ^ kBinary = 0b011.
No changes are required here.

warning: The value '4294967295' provided to the cast expression is not in the valid range of values for 'OperatorArity' [clang-analyzer-optin.core.EnumCastOutOfRange]

    return (OperatorArity)~0U;
           ^

  enum OperatorArity { kUnary = 1, kBinary, kBoth };
       ^

    if (auto* FD = llvm::dyn_cast<FunctionDecl>(D)) {
                   ^

    if (auto* FD = llvm::dyn_cast<FunctionDecl>(D)) {
              ^

    if (auto* FD = llvm::dyn_cast<FunctionDecl>(D)) {
    ^

    return (OperatorArity)~0U;
           ^